home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / xgui / sources / ui_remoteP.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  46.8 KB  |  1,647 lines
  1. /*****************************************************************************
  2.   FILE           : ui_remoteP.c
  3.   SHORTNAME      : remoteP.c
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : routines to control learning, updating the net
  7.   NOTES          : Most of this routines are callbacks of buttons in the remote-
  8.                    panel.
  9.  
  10.   AUTHOR         : Tilman Sommer
  11.   DATE           : 18.7.1990
  12.  
  13.   CHANGED BY     : Michael Vogt, Guenter Mamier
  14.   IDENTIFICATION : @(#)ui_remoteP.c    1.33 4/18/94
  15.   SCCS VERSION   : 1.33 
  16.   LAST CHANGE    : 4/18/94  
  17.  
  18.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  19.              
  20. ******************************************************************************/
  21.  
  22.  
  23. #include <stdio.h>
  24.  
  25. #include "ui.h"
  26. #include "ui_mainP.h"
  27. #include "ui_utilP.h"
  28. #include "ui_selection.h"
  29. #include "ui_netUpdate.h"
  30.  
  31. #include "glob_typ.h"
  32. #include "kr_ui.h"
  33.  
  34. #include "ui_fileP.h"
  35. #include "ui_confirmer.h"
  36. #include "ui_textP.h"
  37. #include "ui_xWidgets.h"
  38. #include "ui_display.h"
  39. #include "ui_action.h"
  40. #include "ui_remote.h"
  41. #include "ui_status.h"
  42. #include "ui_infoP.h"
  43. #include "d3_main.h"
  44. #include "net_analyzer.h"
  45.  
  46. #include "kr_typ.h"
  47. #include "cc_rcc.h"
  48. #include "cc_main.h"
  49. #include "dlvq_learn.h"
  50. #include "ui_inversion.h"
  51. #include "ui_kohonen.h"
  52.  
  53.  
  54. #include "o_graph.h"
  55. #include "ui_main.h"
  56. #include "ui_event.h"
  57.  
  58. #include <X11/Xaw/Form.h>
  59. #include <X11/Shell.h>
  60. #include <X11/Xaw/SmeBSB.h>
  61. #include <X11/IntrinsicP.h>
  62. #include <X11/CoreP.h>
  63. #include <X11/Intrinsic.h>
  64.  
  65. #include "ui_remoteP.ph"
  66.  
  67.  
  68. /*****************************************************************************
  69.   FUNCTION : ui_rem_displayCounter
  70.  
  71.   PURPOSE  : displays the value in ui_numberOfStepsDone in the remote panel
  72.   RETURNS  : void
  73.   NOTES    :
  74.  
  75.   UPDATE   :
  76. *****************************************************************************/
  77. static void ui_rem_displayCounter (void)
  78. {
  79.     char  buf[50];
  80.     if (NOT ui_remoteIsCreated) return;
  81.  
  82.     sprintf(buf,"%d", ui_numberOfStepsDone);
  83.     ui_xSetLabel(ui_numberOfStepsDoneWidget, buf);
  84. }
  85.  
  86.  
  87. /*****************************************************************************
  88.   FUNCTION : ui_rem_displayPatternNumber
  89.  
  90.   PURPOSE  : displays the value in ui_numberOfCurrentPattern in the 
  91.              remote panel
  92.   RETURNS  : void
  93.   NOTES    :
  94.  
  95.   UPDATE   :
  96. *****************************************************************************/
  97. void ui_rem_displayPatternNumber (void)
  98. {
  99.     char  buf[50];
  100.  
  101.     if (NOT ui_remoteIsCreated) return;
  102.  
  103.     sprintf(buf,"%d", ui_noOfCurrentPattern);
  104.     ui_xSetString(ui_numberOfPatternWidget, buf);
  105.     ui_xSetLabel(ui_showPattFile, PATTERN_SET_FILE[CURR_PATTERN_SET]);
  106. }
  107.  
  108.  
  109.  
  110. /*****************************************************************************
  111.   FUNCTION : ui_rem_resetCounter()
  112.  
  113.   PURPOSE  : set counter to 0
  114.   RETURNS  : VOID
  115.   NOTES    :
  116.  
  117.   UPDATE   : 30.7.1990
  118. ******************************************************************************/
  119. void ui_rem_resetCounter (void)
  120. {
  121.     ui_numberOfStepsDone = 0;
  122.     ui_rem_displayCounter();
  123. }
  124.  
  125.  
  126.  
  127. /*****************************************************************************
  128.   FUNCTION : ui_rem_incCounter()
  129.  
  130.   PURPOSE  : increment counter by 1
  131.   RETURNS  :
  132.   NOTES    :
  133.  
  134.   UPDATE   : 30.7.1990
  135. ******************************************************************************/
  136. static void ui_rem_incCounter (void)
  137. {
  138.     ui_numberOfStepsDone += 1;
  139.     ui_rem_displayCounter();
  140. }
  141.  
  142.  
  143. /*****************************************************************************
  144.   FUNCTION : ui_rem_resetNet
  145.  
  146.   PURPOSE  : Resets the net to the initial activation and resets the counter
  147.   NOTES    :
  148.  
  149.   UPDATE   : 24.8.1990
  150. ******************************************************************************/
  151. void ui_rem_resetNet (Widget w, XtPointer button, caddr_t call_data)
  152. {
  153.     ui_sel_reshowItems(ui_currentDisplay, UI_GLOBAL);
  154.     ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_ERASE);
  155.     krui_resetNet();
  156.     ui_rem_resetCounter();
  157.     ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW);
  158.     ui_sel_reshowItems(ui_currentDisplay, UI_GLOBAL);
  159. }
  160.  
  161.  
  162. /*****************************************************************************
  163.   FUNCTION : ui_rem_doInitialization
  164.  
  165.   PURPOSE  : get the parameters and call the kernel
  166.   RETURNS  : void
  167.   NOTES    : 
  168.  
  169.   UPDATE   : 18.3.1991
  170. ******************************************************************************/
  171. void ui_rem_doInitialization (Widget w, caddr_t client_data, caddr_t call_data)
  172. {
  173.     int i;
  174.  
  175.     if(o_open){
  176.       o_CurveNo += ((o_CurveLengths[o_CurveNo] != 0) && 
  177.             (o_CurveNo < MAX_CURVE_NO-1)) ? (1) : (0);
  178.       o_InitCurve();
  179.       o_LearnStepCount = 0;
  180.     }
  181.  
  182.     for (i=0; i< UI_NO_INIT_PARAMS; i++) {
  183.     ui_initParameters[i] =
  184.         ui_xFloatFromAsciiWidget(ui_initParameterWidgets[i]);
  185.     }
  186.     ui_checkError(krui_initializeNet(ui_initParameters, UI_NO_INIT_PARAMS));
  187.     if (ui_displ_isSomeWhereToShowWeights())
  188.     ui_net_completeRefresh(NULL, UI_GLOBAL);
  189.     else {
  190.         ui_net_completeRefresh(NULL, UI_GLOBAL);
  191.     ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW);  
  192.     }
  193.     ui_sel_reshowItems(ui_currentDisplay, UI_GLOBAL);
  194. }
  195.  
  196.  
  197. /*****************************************************************************
  198.   FUNCTION : ui_rem_deleteNet
  199.  
  200.   PURPOSE  : clear SNNS kernel
  201.   RETURNS  : void
  202.   NOTES    : 
  203.  
  204.   UPDATE   : 18.3.1991
  205. ******************************************************************************/
  206.  
  207. void ui_rem_deleteNet (Widget w, caddr_t client_data, caddr_t call_data)
  208.  
  209. {
  210.     if (ui_confirmYes
  211.     ("CLEAR: The network and all patterns will be lost. Clear?")) {
  212.     /* reset kernel */
  213.     krui_deleteNet();
  214.     /* reset gui */
  215.     ui_sel_resetList();       /* reset selections */
  216.     ui_net_completeRefresh(NULL, UI_GLOBAL); /* show net */
  217.     ui_printMessage("");
  218.     ui_stat_displayStatus(ui_gridPosMouse);
  219.     ui_file_updateShellLabels();
  220.     ui_info_makeUnitInfoPanelConsistent();    
  221.         d3_clear_xyTranslationTable ();
  222.     if (INVERS_CREATED) {
  223.            XtDestroyWidget(ui_InvRootWidget);
  224.            INVERS_CREATED = 0;
  225.        }
  226.     }
  227. }
  228.  
  229.  
  230. /*****************************************************************************
  231.   FUNCTION : ui_rem_finishSteps
  232.  
  233.   PURPOSE  : finish performing update steps
  234.   RETURNS  : void
  235.   NOTES    :
  236.  
  237.   UPDATE   : 1.2.1990
  238. ******************************************************************************/
  239.  
  240. static void ui_rem_finishSteps (void)
  241.  
  242. {
  243.     ui_printMessage("");
  244.  
  245.     /* reshow selection markers */
  246.     ui_sel_reshowItems(ui_currentDisplay, UI_GLOBAL); 
  247. }
  248.  
  249.  
  250. /*****************************************************************************
  251.   FUNCTION : ui_rem_performStep
  252.  
  253.   PURPOSE  : called by pressing the button STEPS
  254.   RETURNS  : void
  255.   NOTES    :
  256.  
  257.   UPDATE   :
  258. *****************************************************************************/
  259.  
  260. static Boolean ui_rem_performStep (caddr_t client_data)
  261.  
  262. {
  263.     if (ui_numberOfWorkCycles-- < 1) {
  264.     ui_rem_finishSteps();
  265.     if (NA_ContinueTest()) 
  266.         ui_rem_testProc (NULL, NULL, NULL) ; 
  267.     return(TRUE);
  268.     }
  269.     /* erase the units first, if they have to be drawn with their values
  270.        in numerical form at the bottom (setup parameter) */
  271.     if (ui_displ_isSomeWhereToShowValues())
  272.     ui_net_updateWhole(NULL, UI_GLOBAL, 
  273.                UI_DRAW_UNITS, UI_ERASE_BOTTOM);
  274.     ui_checkError(krui_updateNet(ui_updateParameters, UI_NO_UPDATE_PARAMS));
  275.     ui_rem_incCounter();
  276.     ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW);
  277.     NA_DrawNextPoint () ;
  278.     return(FALSE);
  279. }
  280.  
  281.  
  282. /*****************************************************************************
  283.   FUNCTION : ui_rem_stepsProc
  284.  
  285.   PURPOSE  : perform one or more steps, depending on the PANEL_CLIENT_DATA
  286.              if STEP is pressed one update step in the current mode
  287.          if STEPS is pressed: get the number of steps to perform
  288.          from the panel and go.
  289.   RETURNS  : void
  290.   NOTES    :
  291.  
  292.   UPDATE   :
  293. *****************************************************************************/
  294.  
  295. void  ui_rem_stepsProc (Widget widget, Bool multiStepPressed, caddr_t call_data)
  296.  
  297. { 
  298.     char   buf[80];
  299.     int    i;
  300.  
  301.     if (multiStepPressed) 
  302.     /* MultiSTEPS button */
  303.     if ((ui_numberOfWorkCycles = 
  304.          ui_xIntFromAsciiWidget(ui_numberOfStepsWidget)) <= 0)
  305.         return;
  306.     
  307.     sprintf(buf,"%d steps. Calculating ...", ui_numberOfWorkCycles);
  308.     ui_printMessage(buf);
  309.    
  310.  
  311.     for (i=0; i<UI_NO_UPDATE_PARAMS; i++)
  312.     ui_updateParameters[i] = (float) 
  313.         ui_xFloatFromAsciiWidget(ui_updateParameterWidgets[i]);  
  314.  
  315.     /* erase selection markers */
  316.     ui_sel_reshowItems(ui_currentDisplay, UI_GLOBAL); 
  317.  
  318.    /* Get new Activation Parameter for Kohonen */
  319.    if (kohonen_open) 
  320.      kohonen_SetExtraParameter(ui_xIntFromAsciiWidget(ui_LayerWidget)); 
  321.  
  322.     if (ui_workProcId)
  323.     XtRemoveWorkProc(ui_workProcId); /* kill old workProc */
  324.     ui_workType = UI_STEPS;
  325.     ui_workProcId = 
  326.     XtAppAddWorkProc(ui_appContext, (XtWorkProc) ui_rem_performStep, NULL);
  327.  
  328. }
  329.  
  330.  
  331. /*****************************************************************************
  332.   FUNCTION : ui_rem_moveInPatternsProc             
  333.  
  334.   PURPOSE  : callback. Called when clicked on a cursor button or the GOTO 
  335.              button.
  336.   RETURNS  : void
  337.   NOTES    :
  338.  
  339.   UPDATE   :
  340. *****************************************************************************/
  341. void ui_rem_moveInPatternsProc (Widget w, int moveType, caddr_t call_data)
  342. {
  343.     int   temp;
  344.  
  345.     Bool  doMove = FALSE;
  346.  
  347.     if (krui_getNoOfPatterns() <= 0) {
  348.     ui_confirmOk("No patterns in memory!");
  349.     return;
  350.     }
  351.  
  352.     /* there are patterns */
  353.     switch (moveType) {
  354.       case UI_JUMP: 
  355.     temp = ui_xIntFromAsciiWidget(ui_numberOfPatternWidget);
  356.     if ((temp > 0) AND (temp <= krui_getNoOfPatterns())) {
  357.         ui_noOfCurrentPattern = temp;
  358.         ui_rem_displayPatternNumber();
  359.         doMove = TRUE;
  360.     } else
  361.         ui_confirmOk("pattern goto: invalid number!");
  362.     break;
  363.       case UI_FIRST:
  364.     ui_noOfCurrentPattern = 1;
  365.     ui_rem_displayPatternNumber();
  366.     doMove = TRUE;
  367.     break;
  368.       case UI_LAST:
  369.     ui_noOfCurrentPattern = krui_getNoOfPatterns();
  370.     ui_rem_displayPatternNumber();
  371.     doMove = TRUE;
  372.     break;
  373.       case UI_NEXT:
  374.     if (++ui_noOfCurrentPattern > krui_getNoOfPatterns())
  375.         ui_noOfCurrentPattern = 1;
  376.     ui_rem_displayPatternNumber();
  377.     doMove = TRUE;
  378.     break;
  379.       case UI_PREVIOUS:
  380.     if (--ui_noOfCurrentPattern < 1)
  381.         ui_noOfCurrentPattern = krui_getNoOfPatterns();
  382.     ui_rem_displayPatternNumber();
  383.     doMove = TRUE;
  384.     break;
  385.     }
  386.     
  387.     if (doMove) {
  388.     /* new pattern: reset */
  389.  
  390.     krui_setPatternNo(ui_noOfCurrentPattern);
  391.     ui_rem_getSubPatPanel();
  392.     ui_rem_resetSubPat();
  393.     ui_checkError(krui_DefShowSubPat(subIPatSize,subOPatSize,
  394.                      subIPatPos,subOPatPos));
  395.     ui_rem_resetCounter();
  396.  
  397.     ui_checkError(krui_showPattern(ui_patternLoadMode));
  398.     ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW);
  399.     }
  400. }
  401.  
  402.  
  403. /*****************************************************************************
  404.   FUNCTION : ui_rem_moveInSubPattProc             
  405.  
  406.   PURPOSE  : callback. Called when clicked on a cursor button of the supattern 
  407.              panel.
  408.   RETURNS  : void
  409.   NOTES    :
  410.  
  411.   UPDATE   :
  412. *****************************************************************************/
  413.  
  414. void ui_rem_moveInSubPattProc (Widget w, int moveParam, caddr_t call_data)
  415. {
  416.     int dim, moveType;
  417.     int i;
  418.     pattern_set_info patt_info;
  419.     pattern_descriptor descrip;
  420.     char buf[3];
  421.     krui_err error;
  422.     int i_temp, o_temp, i_save, o_save;
  423.     int maxNpos;      /* value not used */
  424.  
  425.     /* Get information about current pattern set */
  426.  
  427.     if((error = krui_GetPatInfo(&patt_info, &descrip)) < 0){
  428.     ui_checkError(error);
  429.     return;
  430.     }
  431.  
  432.     /* extract parameters */
  433.  
  434.     dim = moveParam / 10;
  435.     moveType = moveParam % 10;
  436.  
  437.  
  438.     /* get subpattern information */
  439.  
  440.     for (i=0; i< subIPatDims; i++) {
  441.     subIPatSize[i] = (int)ui_xIntFromAsciiWidget(subIPatSizeW[i]);
  442.     subIPatStep[i] = (int)ui_xIntFromAsciiWidget(subIPatStepW[i]);
  443.     }
  444.     for (i=0; i< subOPatDims; i++) {
  445.     subOPatSize[i] = (int)ui_xIntFromAsciiWidget(subOPatSizeW[i]);
  446.     subOPatStep[i] = (int)ui_xIntFromAsciiWidget(subOPatStepW[i]);
  447.     }
  448.  
  449.  
  450.     /* compute the new subpattern positions */
  451.  
  452.     switch (moveType) {
  453.       case SP_FIRST:
  454.     i_temp = 1;
  455.     o_temp = 1;
  456.     break;
  457.       case SP_LAST:
  458.     i_temp = descrip.input_dim_sizes[dim] - subIPatSize[dim]+1;
  459.     o_temp = descrip.output_dim_sizes[dim] - subOPatSize[dim]+1;
  460.     break;
  461.       case SP_NEXT:
  462.     if(subIPatPos[dim]+subIPatStep[dim] <= 
  463.                           descrip.input_dim_sizes[dim]-subIPatSize[dim]+1)
  464.         i_temp = subIPatPos[dim] + subIPatStep[dim];
  465.     else
  466.         i_temp = subIPatPos[dim];
  467.     if(subOPatPos[dim]+subOPatStep[dim] <= 
  468.                           descrip.output_dim_sizes[dim]-subOPatSize[dim]+1)
  469.         o_temp = subOPatPos[dim] + subOPatStep[dim];
  470.     else
  471.         o_temp = subOPatPos[dim];
  472.     break;
  473.       case SP_PREVIOUS:
  474.     i_temp = subIPatPos[dim] - subIPatStep[dim];
  475.     if(i_temp < 1)i_temp = 1;
  476.     o_temp = subOPatPos[dim] - subOPatStep[dim];
  477.     if(o_temp < 1)o_temp = 1;
  478.     break;
  479.     }
  480.  
  481.     /* perform the move */
  482.     subIPatPos[dim] = i_temp;
  483.     subOPatPos[dim] = o_temp;
  484.  
  485.     /* validate the desired move */
  486.     ui_checkError(krui_DefTrainSubPat(subIPatSize,subOPatSize,        
  487.                       subIPatStep,subOPatStep,&maxNpos));
  488.     ui_checkError(krui_AlignSubPat(subIPatPos,subOPatPos,&subIPatNo));
  489.  
  490.     if((error = krui_DefShowSubPat(subIPatSize,subOPatSize,
  491.                    subIPatPos,subOPatPos)) < 0){
  492.     ui_checkError(error);
  493.     return;
  494.     }
  495.     if((error = krui_showPattern(ui_patternLoadMode)) < 0){
  496.     ui_checkError(error);
  497.     return;
  498.     }
  499.     ui_net_updateWhole(NULL, UI_GLOBAL, UI_DRAW_UNITS, UI_DRAW);
  500.  
  501.     /* reset labels if move was successful */
  502.     for (i=0; i< subIPatDims; i++) {
  503.     sprintf(buf," %d",subIPatPos[i]);
  504.     ui_xSetLabel(subIPatPosW[i],buf);
  505.     }
  506.     for (i=0; i< subOPatDims; i++){
  507.     sprintf(buf," %d",subOPatPos[i]);
  508.     ui_xSetLabel(subOPatPosW[i],buf);
  509.     }
  510. }
  511.  
  512.  
  513. /*****************************************************************************
  514.   FUNCTION : ui_rem_testProc
  515.  
  516.   PURPOSE  : load the next (or first) pattern and perform the number of steps
  517.              specified in the remote panel in "no of steps"
  518.   RETURNS  : void
  519.   NOTES    :
  520.  
  521.   UPDATE   :
  522. *****************************************************************************/
  523.  
  524. void ui_rem_testProc (Widget w, XtPointer button, caddr_t call_data)
  525.  
  526. {
  527.  
  528.     static int npos = 1;
  529.     int        maxNpos;
  530.  
  531.  
  532.     if (krui_getNoOfPatterns() == 0) {
  533.     char buf[80];
  534.     sprintf(buf,"No patterns present.");
  535.     ui_printMessage(buf);
  536.     return;
  537.     }
  538.  
  539.     /* there are patterns */
  540.  
  541.     if (ui_noOfCurrentPattern > krui_getNoOfPatterns() - 1)
  542.     ui_noOfCurrentPattern = 0; /* set before first pattern */
  543.  
  544.     rcc_currentPattern = ui_noOfCurrentPattern;
  545.  
  546.     /* new pattern: reset */
  547.     ui_rem_resetCounter();
  548.  
  549.     ui_rem_getSubPatPanel();
  550.     ui_checkError(krui_DefTrainSubPat(subIPatSize,subOPatSize,
  551.                       subIPatStep,subOPatStep,&maxNpos));
  552.     ui_checkError(krui_AlignSubPat(subIPatPos,subOPatPos,&npos));
  553.     if(++npos > maxNpos){
  554.     ui_checkError(krui_setPatternNo(++ui_noOfCurrentPattern));
  555.     ui_checkError(krui_DefTrainSubPat(subIPatSize,subOPatSize,
  556.                       subIPatStep,subOPatStep,&maxNpos));
  557.     npos = 1;
  558.     ui_rem_resetSubPat();
  559.     }
  560.     ui_checkError(krui_GetShapeOfSubPattern(subIPatSize,subOPatSize,
  561.                         subIPatPos,subOPatPos,npos));
  562.     ui_checkError(krui_DefShowSubPat(subIPatSize,subOPatSize,
  563.                      subIPatPos,subOPatPos));
  564.     ui_rem_setSubPatPanel();
  565.  
  566.     ui_checkError(krui_showPattern(ui_patternLoadMode));
  567.     ui_rem_displayPatternNumber();
  568.  
  569.     if (ui_xIntFromAsciiWidget(ui_numberOfStepsWidget) < 1)
  570.     ui_net_updateWhole(NULL, UI_GLOBAL, 
  571.                UI_DRAW_UNITS, UI_DRAW);
  572.     else
  573.     ui_rem_stepsProc(NULL, TRUE, NULL); /* multistep */
  574. }
  575.  
  576.  
  577. /*****************************************************************************
  578.   FUNCTION : ui_rem_deleteAllPatternsProc
  579.  
  580.   PURPOSE  : delete all patterns in main memory. The contents of the current
  581.              pattern file (if any) is left unchanged 
  582.   RETURNS  : void
  583.   NOTES    :
  584.  
  585.   UPDATE   : 24.8.1990
  586. ******************************************************************************/
  587.  
  588. void ui_rem_deleteAllPatternsProc (Widget w, XtPointer button, 
  589.                     caddr_t call_data)
  590.  
  591. {
  592.     if (ui_confirmYes("Delete all patterns. Are you sure?")) {
  593.     krui_deleteAllPatterns();
  594.     ui_noOfCurrentPattern = 0;
  595.     ui_rem_displayPatternNumber();
  596.     }
  597. }
  598.  
  599.  
  600. /*****************************************************************************
  601.   FUNCTION : ui_rem_modifyPatternProc
  602.  
  603.   PURPOSE  : calls the kernal in order to store the current visible pattern
  604.              replacing the current pattern. 
  605.   RETURNS  : void 
  606.   NOTES    :
  607.  
  608.   UPDATE   : 18.3.1991
  609. ******************************************************************************/
  610. void ui_rem_modifyPatternProc (Widget w, XtPointer button, caddr_t call_data)
  611. {
  612.     int temp = ui_xIntFromAsciiWidget(ui_numberOfPatternWidget);
  613.  
  614.     newPatternsLoaded = 1;
  615.  
  616.     if ((temp > 0) AND (temp <= krui_getNoOfPatterns())) {
  617.     ui_noOfCurrentPattern = temp;
  618.     krui_setPatternNo(ui_noOfCurrentPattern);
  619.     ui_checkError(krui_modifyPattern());
  620.     if (ui_noOfCurrentPattern > krui_getNoOfPatterns()) {
  621.         ui_noOfCurrentPattern = krui_getNoOfPatterns();
  622.         ui_rem_displayPatternNumber();
  623.     } 
  624.     } else
  625.     ui_confirmOk("modify pattern: invalid pattern number!");
  626. }
  627.  
  628.  
  629. /*****************************************************************************
  630.   FUNCTION : ui_rem_deletePatternProc
  631.  
  632.   PURPOSE  : calls the kernal in order to delete the current visible pattern.
  633.   RETURNS  : void
  634.   NOTES    :
  635.  
  636.   UPDATE   : 18.3.1991
  637. ******************************************************************************/
  638. void ui_rem_deletePatternProc (Widget w, XtPointer button, caddr_t call_data)
  639. {
  640.     int temp = ui_xIntFromAsciiWidget(ui_numberOfPatternWidget);
  641.  
  642.     newPatternsLoaded = 1;
  643.  
  644.     if ((temp > 0) AND (temp <= krui_getNoOfPatterns())) {
  645.     ui_noOfCurrentPattern = temp;
  646.     krui_setPatternNo(ui_noOfCurrentPattern);
  647.     ui_checkError(krui_deletePattern());
  648.     if (ui_noOfCurrentPattern > krui_getNoOfPatterns()) {
  649.         ui_noOfCurrentPattern = krui_getNoOfPatterns();
  650.         ui_rem_displayPatternNumber();
  651.     } 
  652.     } else
  653.     ui_confirmOk("delete pattern: invalid pattern number!");
  654. }
  655.  
  656.  
  657. /*****************************************************************************
  658.   FUNCTION : ui_rem_newPatternProc
  659.  
  660.   PURPOSE  : calls the kernel in order to store the current visible pattern
  661.              as a new one. This new pattern will be appended.
  662.   RETURNS  : void
  663.   NOTES    :
  664.  
  665.   UPDATE   : 24.8.1990
  666. ******************************************************************************/
  667. void ui_rem_newPatternProc (Widget w, XtPointer button, caddr_t call_data)
  668. {
  669.     pattern_set_info   patt_info;
  670.     pattern_descriptor descrip;
  671.     int error,setNo;
  672.  
  673.     if(NO_OF_PATTERN_SETS == 0){
  674.     if((error = krui_allocNewPatternSet(&setNo)) < 0){
  675.         ui_checkError(error);
  676.         return;
  677.     }
  678.     ui_noOfCurrentPattern = 1;
  679.     NO_OF_PATTERN_SETS = 1;
  680.     CURR_PATTERN_SET = setNo;
  681.  
  682.     /* set the widgets labels */
  683.     PATTERN_SET_FILE[CURR_PATTERN_SET] = (char *)malloc(8);
  684.     strcpy(PATTERN_SET_FILE[CURR_PATTERN_SET],"New Set");
  685.     ui_rem_updatePattList();
  686.  
  687.     }else if(krui_getNoOfPatterns() > 0){
  688.     if((error = krui_GetPatInfo(&patt_info, &descrip)) < 0){
  689.         ui_checkError(error);
  690.         return;
  691.     }
  692.     if(patt_info.in_number_of_dims>0 || patt_info.out_number_of_dims>0){
  693.         ui_confirmOk("NEW not allowed with variable sized patterns!");
  694.         return;
  695.     }
  696.     }
  697.  
  698.     newPatternsLoaded = 1;
  699.     ui_checkError(krui_newPattern());
  700.     ui_noOfCurrentPattern = krui_getNoOfPatterns();
  701.     ui_rem_displayPatternNumber();
  702. }
  703.  
  704.  
  705.  
  706. /*****************************************************************************
  707.   FUNCTION : ui_rem_printLearnInfo
  708.  
  709.   PURPOSE  : print information about last learning cycle
  710.   RETURNS  : void
  711.   NOTES    : Kohonen requires additional information to be displayed during
  712.              learning. Therefore a special section is included here.
  713.  
  714.   UPDATE   : 23.03.94 by Sven Doering
  715. ******************************************************************************/
  716. static void ui_rem_printLearnInfo (void)
  717. {
  718.     char    buf[MAX_NAME_LENGTH];
  719.     int     i,j;
  720.     static float temp1, temp2;
  721.     static int times = 1;
  722.     int pats;
  723.  
  724.     if(strcmp("Kohonen",krui_getLearnFunc()) == 0){
  725.     if(INIT_KOHONEN_PRINT == 1){
  726.         times = 1;
  727.         INIT_KOHONEN_PRINT = 0; /* The variable is set when pressing the
  728.                        ALL and SINGLE Buttons in the remote */
  729.         temp1 =(float)ui_xFloatFromAsciiWidget(ui_learnParameterWidgets[0]);
  730.         temp2 =(float)ui_xFloatFromAsciiWidget(ui_learnParameterWidgets[1]);
  731.     }else{
  732.         times = ui_numberOfLearnCycles DIV 10;
  733.     }
  734.     pats = krui_getNoOfPatterns();
  735.     for(j=1; j<= times; j++)
  736.         for(i=1; i<=pats; i++){
  737.         /* this is a copy of the adaption process in the kernel for
  738.            display reasons */
  739.         temp1 *= ui_learnParameters[2];
  740.         temp2 *= ui_learnParameters[3];
  741.         }
  742.     /* Adapt the displayed values of the first two learning parameters 
  743.        in the remote panel */
  744.     sprintf(buf,"%7.5f",temp1);
  745.     strncpy(buf,buf,7);
  746.     ui_xSetString(ui_learnParameterWidgets[0], buf);
  747.     sprintf(buf,"%7.5f",temp2);
  748.     strncpy(buf,buf,7);
  749.     ui_xSetString(ui_learnParameterWidgets[1], buf);
  750.     }
  751.  
  752.     sprintf(buf,"  %5d:", ui_numberOfWorkCycles + 1);
  753.     ui_tw_printMessage(buf);
  754.     sprintf(buf,"    %10.5f",ui_errorArray[0]);
  755.     ui_tw_printMessage(buf);
  756.     sprintf(buf,"     %10.5f",(ui_errorArray[0]/krui_getNoOfPatterns()));
  757.     ui_tw_printMessage(buf);
  758.     if (krui_getNoOfOutputUnits() > 0) {
  759.     sprintf(buf,"        %10.5f\n", 
  760.         (ui_errorArray[0]/krui_getNoOfOutputUnits()));
  761.     ui_tw_printMessage(buf);
  762.     } else
  763.     ui_tw_printMessage("\n");
  764. }
  765.  
  766.  
  767. /*****************************************************************************
  768.   FUNCTION : ui_rem_finishLearning
  769.  
  770.   PURPOSE  : finish performing learning cycles
  771.   RETURNS  : void
  772.   NOTES    :
  773.  
  774.   UPDATE   : 1.2.1990
  775. ******************************************************************************/
  776.  
  777. static void ui_rem_finishLearning (void)
  778.  
  779. {
  780.     /* bring the patterns back into their old order before shuffling was done */
  781.     if (ui_shuffleFlg) 
  782.     ui_checkError(krui_shufflePatterns(FALSE));
  783.     if (ui_shuffleSubPatFlg) 
  784.     ui_checkError(krui_shuffleSubPatterns(FALSE));
  785.     
  786.     if (ui_displ_isSomeWhereToShowWeights())
  787.     ui_net_completeRefresh(NULL, UI_GLOBAL);
  788.     else {
  789.           cc_updatePosOfSpecialUnits();
  790.           ui_net_completeRefresh(NULL, UI_GLOBAL);
  791.     ui_net_updateWhole(NULL, UI_GLOBAL, 
  792.                UI_DRAW_UNITS, UI_DRAW);
  793.     }
  794. }
  795.  
  796.  
  797. /*****************************************************************************
  798.   FUNCTION : ui_rem_performLearn
  799.  
  800.   PURPOSE  : perform learning cycles
  801.   RETURNS  :
  802.   NOTES    :
  803.  
  804.   UPDATE   : 1.2.1990
  805. ******************************************************************************/
  806.  
  807. static Boolean ui_rem_performLearn (int learnType)
  808.  
  809. {
  810.     krui_err err;
  811.  
  812.     dlvq_numberOfLearnCycles = ui_numberOfLearnCycles; 
  813.  
  814.     if (ui_numberOfWorkCycles-- < 1) {
  815.     ui_rem_finishLearning();
  816.     return(TRUE);
  817.     }
  818.  
  819.     switch (learnType) {
  820.       case UI_LEARN_ALL:
  821.     if (ui_shuffleFlg) 
  822.         ui_checkError(krui_shufflePatterns(TRUE));
  823.     if (ui_shuffleSubPatFlg) 
  824.         ui_checkError(krui_shuffleSubPatterns(TRUE));
  825.     ui_checkError(err = krui_learnAllPatterns(ui_learnParameters, 
  826.                    UI_NO_LEARN_PARAMS+UI_NO_OF_CASCADE_PARAMS,
  827.                         &ui_errorArray,
  828.                         &ui_noErrorArrayElements));
  829.         if (err != KRERR_NO_ERROR)
  830.             return (TRUE);
  831.     break;
  832.       case UI_LEARN_SINGLE:
  833.     if ((ui_noOfCurrentPattern <= krui_getNoOfPatterns()) AND
  834.         (ui_noOfCurrentPattern > 0)) {
  835.         ui_checkError(err = krui_learnSinglePattern(ui_noOfCurrentPattern,
  836.                           ui_learnParameters,
  837.                   UI_NO_LEARN_PARAMS+UI_NO_OF_CASCADE_PARAMS,
  838.                           &ui_errorArray,
  839.                           &ui_noErrorArrayElements));
  840.             if (err != KRERR_NO_ERROR)
  841.                 return (TRUE);
  842.     } else
  843.         ui_confirmOk("Can't learn current pattern.");
  844.     break;
  845.     }
  846.  
  847.     if ((ui_numberOfWorkCycles == ui_numberOfLearnCycles) or
  848.     (ui_numberOfWorkCycles == 0) or
  849.     (ui_numberOfLearnCycles <= 10) or
  850.     (((ui_numberOfWorkCycles+1) MOD (ui_numberOfLearnCycles DIV 10)) == 0)){
  851.     ui_rem_printLearnInfo();
  852.         ui_displWeightsFromUpdate();
  853.     }
  854.  
  855.     if(o_open){
  856.       o_draw(ui_errorArray[0]/krui_getNoOfOutputUnits());
  857.       if(ui_numberOfWorkCycles == 0){
  858.         o_PressPossible = 1;
  859.       }
  860.     }
  861.     return(FALSE);
  862. }
  863.  
  864.  
  865. /*****************************************************************************
  866.   FUNCTION : ui_rem_learnProc
  867.  
  868.   PURPOSE  : call the learn procedure of the kernel. The number of learn cycles
  869.              is determined by the user and also the learn parameter.
  870.   RETURNS  : implicite alteration of the network
  871.   NOTES    : 
  872.  
  873.   UPDATE   :
  874. *****************************************************************************/
  875.  
  876. void ui_rem_learnProc (Widget w, int learnType, caddr_t call_data)
  877.  
  878. {
  879.     char  buf[MAX_NAME_LENGTH];
  880.     int   i, maxNpos;
  881.     
  882.     o_PressPossible = 0;
  883.  
  884.       cc_readElements();
  885.       cc_allButtonIsPressed = 1;
  886.  
  887.     /* check now for errors and react ! */
  888.     if (krui_getNoOfPatterns == 0) {
  889.     ui_confirmOk("No patterns loaded/created!");
  890.     return;
  891.     }
  892.  
  893.     ui_rem_getSubPatPanel ();
  894.     ui_rem_resetSubPat();
  895.     ui_checkError(krui_DefTrainSubPat(subIPatSize,subOPatSize,
  896.                       subIPatStep,subOPatStep,&maxNpos));
  897.  
  898.     ui_numberOfWorkCycles = /* this value will be decreased */
  899.     ui_xIntFromAsciiWidget(ui_numberOfCyclesWidget);
  900.     ui_numberOfLearnCycles = /* this value stays constant */
  901.     ui_numberOfWorkCycles;
  902.     for (i=0; i<UI_NO_LEARN_PARAMS; i++)
  903.     ui_learnParameters[i] = (float) 
  904.         ui_xFloatFromAsciiWidget(ui_learnParameterWidgets[i]);
  905.     
  906.     if (learnType == UI_LEARN_ALL)
  907.     ui_tw_printMessage("\nLearning all patterns:\n");
  908.     else
  909.     ui_tw_printMessage("\nLearning current pattern:\n");
  910.  
  911.     sprintf(buf,
  912.         "  epochs   : %d\n  parameter: %8.5f\n  #o-units : %d\n  #patterns: %d\n", 
  913.         ui_numberOfWorkCycles, ui_learnParameters[0], 
  914.         krui_getNoOfOutputUnits(),krui_getNoOfPatterns());
  915.     ui_tw_printMessage(buf);
  916.     sprintf(buf,
  917.         "\n  epoch:         SSE            MSE            SSE/o-units\n\n");
  918.     ui_tw_printMessage(buf);
  919.     INIT_KOHONEN_PRINT = 1; /*Enables the print kommands for kohonen */
  920.     
  921.     NA_StopTest () ;
  922.     if (ui_workProcId)
  923.     XtRemoveWorkProc(ui_workProcId); /* kill old workProc */
  924.     ui_workType = UI_LEARN;
  925.     ui_workProcId = XtAppAddWorkProc(ui_appContext, 
  926.                      (XtWorkProc) ui_rem_performLearn, 
  927.                      (XtPointer) learnType); 
  928.  
  929. }
  930.  
  931.  
  932. /*****************************************************************************
  933.   FUNCTION : ui_rem_stopProc
  934.  
  935.   PURPOSE  : callback. Called after click on STOP button
  936.   RETURNS  : void
  937.   NOTES    :
  938.  
  939.   UPDATE   :
  940. *****************************************************************************/
  941.  
  942. void  ui_rem_stopProc (Widget widget, caddr_t client_data, caddr_t call_data)
  943.  
  944. { 
  945.     if (ui_workProcId) { 
  946.     switch (ui_workType) { 
  947.       case UI_STEPS: 
  948.         ui_rem_finishSteps(); break;
  949.       case UI_LEARN:
  950.         ui_rem_finishLearning();
  951.         ui_rem_printLearnInfo();
  952.         break;
  953.     }
  954.     NA_StopTest () ;
  955.     XtRemoveWorkProc(ui_workProcId); /* kill workProc */
  956.     ui_workProcId = 0;
  957.     ui_numberOfWorkCycles = 0;
  958.     }
  959.     o_PressPossible = 1;
  960. }
  961.  
  962.  
  963. /*****************************************************************************
  964.   FUNCTION : ui_rem_shuffleProc
  965.  
  966.   PURPOSE  : notify procedure of the toggle item, to remember the status of
  967.              it.
  968.   RETURNS  : changes the flag ui_shuffleFlg
  969.   NOTES    :
  970.  
  971.   UPDATE   :
  972. *****************************************************************************/
  973. void ui_rem_shuffleProc (Widget w, caddr_t client, caddr_t call)
  974. {
  975.     ui_shuffleFlg = ui_xGetToggleState(w);
  976. }
  977.  
  978.  
  979. /*****************************************************************************
  980.   FUNCTION : ui_rem_showModeProc
  981.  
  982.   PURPOSE  : notify procedure of the panel cycle.
  983.   RETURNS  : sets the variable ui_patternLoadMode
  984.   NOTES    :
  985.  
  986.   UPDATE   :
  987. *****************************************************************************/
  988. void ui_rem_showModeProc (Widget w, int value, caddr_t call_data)
  989. {    
  990.     ui_patternLoadMode = (int) value;
  991.     switch (value) {
  992.       case OUTPUT_NOTHING:
  993.     ui_xSetLabel(ui_showModeLabel, "none");
  994.     break;
  995.       case OUTPUT_OUT:
  996.     ui_xSetLabel(ui_showModeLabel, "output");
  997.     break;
  998.       case OUTPUT_ACT:
  999.     ui_xSetLabel(ui_showModeLabel, "activation");
  1000.     break;
  1001.     }
  1002. }
  1003.  
  1004.  
  1005. /*****************************************************************************
  1006.   FUNCTION : ui_rem_setRandomWeights
  1007.  
  1008.   PURPOSE  : set weights of all links randomly
  1009.   RETURNS  : void
  1010.   NOTES    :
  1011.  
  1012.   UPDATE   :
  1013. *****************************************************************************/
  1014. void ui_rem_setRandomWeights (Widget w, int randomType, caddr_t call_data)
  1015. {    
  1016.     FlintType  low, high, temp;
  1017.  
  1018.     low  = (FlintType) ui_xFloatFromAsciiWidget(ui_lowLimitWidget);
  1019.     high = (FlintType) ui_xFloatFromAsciiWidget(ui_highLimitWidget);
  1020.     if (low > high) {
  1021.     temp = low;
  1022.     low  = high;
  1023.     high = temp;
  1024.     }
  1025.  
  1026.     switch (randomType) {
  1027.       case UI_RANDOM:
  1028.     /* krui_randomizeWeights(low, high); */       
  1029.     break;
  1030.       case UI_JOG:
  1031.     krui_jogWeights(low, high);
  1032.     break;
  1033.     }
  1034.     if (ui_displ_isSomeWhereToShowWeights())
  1035.     ui_net_completeRefresh(NULL, UI_GLOBAL);
  1036. }
  1037.  
  1038.  
  1039. /*****************************************************************************
  1040.   FUNCTION : ui_rem_getKernelInfo
  1041.  
  1042.   PURPOSE  : get some info from the kernel. Output to text window
  1043.   RETURNS  : void
  1044.   NOTES    :
  1045.  
  1046.   UPDATE   : 1.2.1990
  1047. ******************************************************************************/
  1048. void ui_rem_getKernelInfo (Widget w, XtPointer button, caddr_t call_data)
  1049. {
  1050.     char   buf[127];
  1051.     int    no_of_sites, no_of_links, no_of_STable_entries, no_of_FTable_entries;
  1052.     int    unit_bytes, site_bytes, link_bytes, 
  1053.            NTable_bytes, STable_bytes, FTable_bytes;
  1054.  
  1055.     sprintf(buf,"\n%s :\n\n", krui_getVersion());
  1056.     ui_tw_printMessage(buf);
  1057.  
  1058.     krui_getNetInfo(&no_of_sites, &no_of_links,
  1059.             &no_of_STable_entries, &no_of_FTable_entries);
  1060.  
  1061.     sprintf(buf,"#input  units: %6d\n#output units: %6d\n#patterns    : %6d\n",
  1062.         krui_getNoOfInputUnits(), krui_getNoOfOutputUnits(), 
  1063.         krui_getNoOfPatterns());
  1064.     ui_tw_printMessage(buf);
  1065.     sprintf(buf,"#sites       : %6d\n#links       : %6d\n",
  1066.         no_of_sites, no_of_links);
  1067.     ui_tw_printMessage(buf);
  1068.     sprintf(buf,"#STable entr.: %6d\n#FTable-Entr.: %6d\n\n",
  1069.         no_of_STable_entries, no_of_FTable_entries);
  1070.     ui_tw_printMessage(buf);
  1071.  
  1072.     ui_tw_printMessage("sizes in bytes:\n");
  1073.     krui_getMemoryManagerInfo(&unit_bytes, &site_bytes, &link_bytes,
  1074.                   &NTable_bytes, &STable_bytes, &FTable_bytes);
  1075.     sprintf(buf,"units        : %7d\nsites        : %7d\nlinks        : %7d\n",
  1076.         unit_bytes, site_bytes, link_bytes);
  1077.     ui_tw_printMessage(buf);
  1078.     sprintf(buf,"NTable       : %7d\nSTable       : %7d\nFTable       : %7d\n\n"
  1079.         ,NTable_bytes, STable_bytes, FTable_bytes);
  1080.     ui_tw_printMessage(buf);
  1081.     sprintf(buf,"learning function  : %s\n", krui_getLearnFunc());
  1082.     ui_tw_printMessage(buf);
  1083.     sprintf(buf,"update function    : %s\n", krui_getUpdateFunc());
  1084.     ui_tw_printMessage(buf);
  1085.     sprintf(buf,"initialize function: %s\n", krui_getInitialisationFunc());
  1086.     ui_tw_printMessage(buf);
  1087.  
  1088.     ui_tw_printMessage("\n\n");
  1089. }
  1090.  
  1091.  
  1092. /*****************************************************************************
  1093.   FUNCTION : ui_rem_shuffleSubPatProc
  1094.  
  1095.   PURPOSE  : notify procedure of the toggle item, to remember the status of
  1096.              it.
  1097.   RETURNS  : changes the flag ui_shuffleSubPatFlg
  1098.   NOTES    :
  1099.  
  1100.   UPDATE   :
  1101. *****************************************************************************/
  1102. void ui_rem_shuffleSubPatProc (Widget w, caddr_t client, caddr_t call)
  1103. {
  1104.     ui_shuffleSubPatFlg = ui_xGetToggleState(w);
  1105. }
  1106.  
  1107.  
  1108. /*****************************************************************************
  1109.   FUNCTION : ui_rem_defSubPat
  1110.  
  1111.   PURPOSE  : creates the panel to handle sub patterns 
  1112.   RETURNS  : void
  1113.   NOTES    :
  1114.  
  1115.   UPDATE   : 16.09.1993
  1116. ******************************************************************************/
  1117. void ui_rem_defSubPat (Widget button, int refreshType, caddr_t call_data)
  1118. {
  1119.     Widget             sbutton,lab1,ui_pop_exit,ui_pop,above,
  1120.                        isize,istep,itot,otot,osize,ostep;
  1121.     static Widget      form,title1,title2,left,subPatDoneW,
  1122.                        input,output,ipos,opos;
  1123.     Arg                args[5];
  1124.     Position           x, y;
  1125.     Dimension          width, height;
  1126.     Cardinal           n;
  1127.     char               buf[120];
  1128.     int                i;
  1129.     krui_err           error;
  1130.     pattern_set_info   patt_info;
  1131.     pattern_descriptor descrip;
  1132.     Window             rdummy;
  1133.     int                x1, y1, border;
  1134.     unsigned int       wdummy, hdummy, bdummy, ddummy;
  1135.  
  1136.  
  1137.     /* Get information about current pattern set */
  1138.  
  1139.     if(NO_OF_PATTERN_SETS == 0){
  1140.     if(refreshType == 0){
  1141.         ui_confirmOk("No Patterns present !");
  1142.         return;
  1143.     }else{
  1144.         /* call came from ui_rem_delPatSet which deleted last pattern */
  1145.         /* set. Therefore destroy panel                               */
  1146.         XtCallCallbacks(subPatDoneW,XtNcallback,
  1147.                 (caddr_t) UI_POPUP_SUBPATTERN);
  1148.         return;
  1149.     }
  1150.     }
  1151.  
  1152.  
  1153.     if((refreshType == 1) && (SubPatPanel < 1))
  1154.     /* can't refresh, if panel was never created yet */
  1155.     return;
  1156.  
  1157.     if((error = krui_GetPatInfo(&patt_info, &descrip)) < 0){
  1158.     ui_checkError(error);
  1159.     return;
  1160.     }
  1161.  
  1162.     if(patt_info.in_number_of_dims == 0){
  1163.     if(SubPatPanel < 1){
  1164.         ui_confirmOk("Pattern has no variable dimension !");
  1165.         return;
  1166.     }else{
  1167.         /* New pattern set does not allow this panel */
  1168.         XtCallCallbacks(subPatDoneW,XtNcallback,
  1169.                 (caddr_t) UI_POPUP_SUBPATTERN);
  1170.         return;
  1171.     }
  1172.  
  1173.     }
  1174.  
  1175.     if(refreshType == 0){ /*panel has to be created */
  1176.  
  1177.     if(SubPatPanel == 1)
  1178.         /* panel was supposed to be created but exists already */
  1179.         return;
  1180.  
  1181.     /* Upper left corner will be in the center of the calling button */
  1182.  
  1183.     ui_xGetDimensions(button, &width, &height);
  1184.     XtTranslateCoords(button, (Position) (width / 2), 
  1185.               (Position) (height / 2),&x, &y);
  1186.     
  1187.     n = 0;
  1188.     XtSetArg(args[n], XtNx, x); n++;
  1189.     XtSetArg(args[n], XtNy, y); n++;
  1190.  
  1191.     /* Now create Popup */
  1192.     
  1193.     ui_popPattern =
  1194.         XtCreatePopupShell("Sub Pattern Handling", 
  1195.                 topLevelShellWidgetClass,ui_toplevel,args,n);
  1196.     }else{
  1197.  
  1198.     /* Recreate the panel */
  1199.  
  1200.     n = 0;
  1201.     XtSetArg(args[n], XtNx, &x); n++;
  1202.     XtSetArg(args[n], XtNy, &y); n++;
  1203.     XtSetArg(args[n], XtNborderWidth, &border); n++;
  1204.     XtGetValues(ui_popPattern, args, n);
  1205.     XGetGeometry(ui_display, (*ui_popPattern).core.window, &rdummy, 
  1206.              &x1, &y1, &wdummy, &hdummy, &bdummy, &ddummy);
  1207.     XtDestroyWidget(ui_popPattern);
  1208.  
  1209.     n = 0;
  1210.     XtSetArg(args[n], XtNx, x-x1-bdummy-1); n++;
  1211.     XtSetArg(args[n], XtNy, y-y1-bdummy-1); n++;
  1212.         ui_popPattern =
  1213.         XtCreatePopupShell("Sub Pattern Handling", 
  1214.                 transientShellWidgetClass,ui_toplevel,args,n);
  1215.     }
  1216.     ui_pop = 
  1217.     XtCreateManagedWidget("frame",formWidgetClass,ui_popPattern,
  1218.                   NULL,0);
  1219.     
  1220.     XtSetArg(args[n], XtNborderWidth, 1); 
  1221.     form = XtCreateManagedWidget("form", formWidgetClass, ui_pop, args, 1);
  1222.     
  1223.     sprintf(buf,"                               Input");
  1224.     title1 = ui_xCreateLabelItem(buf,form,41*8,NULL,NULL);
  1225.     sprintf(buf,"       Output");
  1226.     title2 = ui_xCreateLabelItem(buf,form,14*8,title1,NULL);
  1227.     
  1228.     n = 0;
  1229.     XtSetArg(args[n], XtNborderWidth,  0); n++;
  1230.     XtSetArg(args[n], XtNfromHoriz, NULL); n++;
  1231.     XtSetArg(args[n], XtNfromVert, title1); n++;
  1232.     left = XtCreateManagedWidget("left", formWidgetClass, form, args, n);
  1233.     sprintf(buf,"     ");
  1234.     title1 = ui_xCreateLabelItem(buf,left,9*8,NULL,NULL);
  1235.  
  1236.     sbutton = ui_xCreateToggleItem("shuffle", left, NULL, title1, NULL);
  1237.     XtAddCallback(sbutton, XtNcallback, 
  1238.           (XtCallbackProc) ui_rem_shuffleSubPatProc, NULL);
  1239.  
  1240.     subIPatDims = patt_info.in_number_of_dims;
  1241.     subOPatDims = patt_info.out_number_of_dims;
  1242.  
  1243.     above = sbutton;
  1244.  
  1245.     for (i=0; i< subIPatDims; i++) {
  1246.         sprintf(buf,"dim %d :",i+1);
  1247.     lab1 = ui_xCreateLabelItem(buf, left, 7*8, NULL, above);
  1248.  
  1249.     sbutton = ui_xCreateButtonItem("first",left,lab1,above);
  1250.     XtAddCallback(sbutton, XtNcallback, 
  1251.               (XtCallbackProc)ui_rem_moveInSubPattProc,
  1252.               (caddr_t)(SP_FIRST + i*10));
  1253.     
  1254.     sbutton = ui_xCreateButtonItem("prev",left, sbutton, above);
  1255.     XtAddCallback(sbutton, XtNcallback, 
  1256.               (XtCallbackProc)ui_rem_moveInSubPattProc,
  1257.               (caddr_t)(SP_PREVIOUS + i*10));
  1258.  
  1259.     sbutton = ui_xCreateButtonItem("next",left, sbutton, above);
  1260.     XtAddCallback(sbutton, XtNcallback, 
  1261.               (XtCallbackProc) ui_rem_moveInSubPattProc,
  1262.               (caddr_t) (SP_NEXT + i*10));
  1263.  
  1264.     sbutton = ui_xCreateButtonItem("last",left, sbutton, above);
  1265.     XtAddCallback(sbutton, XtNcallback,
  1266.               (XtCallbackProc) ui_rem_moveInSubPattProc,
  1267.               (caddr_t) (SP_LAST + i*10));
  1268.     
  1269.     above = lab1;
  1270.     }
  1271.  
  1272.     n = 0;
  1273.     XtSetArg(args[n], XtNborderWidth,  1); n++;
  1274.     XtSetArg(args[n], XtNfromHoriz, left); n++;
  1275.     XtSetArg(args[n], XtNfromVert, title1); n++;
  1276.     input  = XtCreateManagedWidget("input", formWidgetClass, form, args, n);
  1277.     ipos  = ui_xCreateLabelItem("Pos ",input,4*8,NULL,NULL);
  1278.     itot  = ui_xCreateLabelItem("Tot ",input,4*8,ipos,NULL);
  1279.     isize = ui_xCreateLabelItem("Size",input,4*8,itot,NULL);
  1280.     istep = ui_xCreateLabelItem("Step",input,4*8,isize,NULL);
  1281.  
  1282.     above = ipos;
  1283.  
  1284.     for (i=0; i< subIPatDims; i++) {
  1285.         sprintf(buf," %d",subIPatPos[i]);
  1286.     subIPatPosW[i] = ui_xCreateLabelItem(buf,input,4*8,NULL,above);
  1287.  
  1288.         sprintf(buf," %d",descrip.input_dim_sizes[i]);
  1289.     in_dim_widgets[i] = ui_xCreateLabelItem(buf,input,5*8,
  1290.                            subIPatPosW[i],above);
  1291.         sprintf(buf,"%d",subIPatSize[i]);
  1292.         subIPatSizeW[i] = ui_xCreateDialogItem("param",input,buf,4*8,
  1293.                            in_dim_widgets[i],above);
  1294.  
  1295.         sprintf(buf,"%d",subIPatStep[i]);
  1296.     subIPatStepW[i] = ui_xCreateDialogItem("param",input,buf,4*8, 
  1297.                            subIPatSizeW[i],above);
  1298.  
  1299.     above = subIPatPosW[i];
  1300.  
  1301.     }
  1302.  
  1303.     n = 0;
  1304.     XtSetArg(args[n], XtNborderWidth,  1); n++;
  1305.     XtSetArg(args[n], XtNfromHoriz, input); n++;
  1306.     XtSetArg(args[n], XtNfromVert, title2); n++;
  1307.     output = XtCreateManagedWidget("output",formWidgetClass,form,args,n);
  1308.     opos  = ui_xCreateLabelItem("Pos ",output,4*8,NULL,NULL);
  1309.     otot  = ui_xCreateLabelItem("Tot ",output,4*8,opos,NULL);
  1310.     osize = ui_xCreateLabelItem("Size",output,4*8,otot,NULL);
  1311.     ostep = ui_xCreateLabelItem("Step",output,4*8,osize,NULL);
  1312.     
  1313.     above = opos;
  1314.  
  1315.     for (i=0; i<subOPatDims; i++) {
  1316.         sprintf(buf," %d",subOPatPos[i]);
  1317.     subOPatPosW[i]  = ui_xCreateLabelItem(buf,output,4*8,NULL,above);
  1318.  
  1319.         sprintf(buf," %d",descrip.output_dim_sizes[i]);
  1320.         out_dim_widgets[i] = ui_xCreateLabelItem(buf,output,5*8,
  1321.                             subOPatPosW[i],above);
  1322.         sprintf(buf,"%d",subOPatSize[i]);
  1323.         subOPatSizeW[i] = ui_xCreateDialogItem("param",output,buf,4*8,
  1324.                            out_dim_widgets[i],above);
  1325.  
  1326.         sprintf(buf,"%d",subOPatStep[i]);
  1327.         subOPatStepW[i] = ui_xCreateDialogItem("param",output,buf,4*8, 
  1328.                            subOPatSizeW[i],above);
  1329.  
  1330.     above = subOPatStepW[i];
  1331.  
  1332.     }
  1333.  
  1334.     
  1335.     subPatDoneW = ui_xCreateButtonItem("done", ui_pop, NULL, form);
  1336.     XtAddCallback(subPatDoneW, XtNcallback, (XtCallbackProc) ui_popupDone, 
  1337.           (caddr_t) UI_POPUP_SUBPATTERN);
  1338.                   /*!*/  /* constant name is meaningless ! */
  1339.  
  1340.     ui_checkWindowPosition(ui_popPattern);
  1341.     XtPopup(ui_popPattern, XtGrabNone);
  1342.     ui_xDontResizeWidget(ui_popPattern); 
  1343.     SubPatPanel = 1;
  1344. }
  1345.  
  1346.  
  1347.  
  1348.  
  1349. /*****************************************************************************
  1350.   FUNCTION : ui_rem_usePattSet
  1351.  
  1352.   PURPOSE  : Switches between different pattern sets
  1353.   RETURNS  : void
  1354.   NOTES    :
  1355.  
  1356.   UPDATE   : 13.09.1991
  1357. ******************************************************************************/
  1358. void ui_rem_usePattSet (Widget button, int setNo, caddr_t call_data)
  1359. {
  1360.     int error;
  1361.  
  1362.  
  1363.     if(CURR_PATTERN_SET == setNo)
  1364.     return;
  1365.  
  1366.     if((error = krui_setCurrPatSet(setNo)) < 0){
  1367.     ui_checkError(error);
  1368.     return;
  1369.     }
  1370.  
  1371.     CURR_PATTERN_SET = setNo;
  1372.     ui_noOfCurrentPattern = 1;
  1373.     ui_xSetLabel(ui_showPattFile, PATTERN_SET_FILE[CURR_PATTERN_SET]);
  1374.  
  1375.  
  1376.     /* refresh the subpattern panel */
  1377.     ui_rem_defSubPat(button,1,(caddr_t)1);
  1378.  
  1379.     /* refresh the pattern panel */
  1380.     ui_rem_displayPatternNumber();
  1381. }
  1382.  
  1383.  
  1384.  
  1385.  
  1386. /*****************************************************************************
  1387.   FUNCTION : ui_rem_delPattSet
  1388.  
  1389.   PURPOSE  : deletes a pattern set
  1390.   RETURNS  : void
  1391.   NOTES    : DELPattFileWidget[0] and USEPattFileWidget[0] ALWAYS have 
  1392.              callbacks defined, even when the label shows "No Files" !
  1393.          This function has to take care that nothing happens in case no 
  1394.          files are present
  1395.  
  1396.   UPDATE   : 11.11.1991
  1397. ******************************************************************************/
  1398. void ui_rem_delPattSet (Widget button, int setNo, caddr_t call_data)
  1399. {
  1400.     Arg arg[10];
  1401.     char buf[80];
  1402.     int  i;
  1403.     Widget tempWidget;
  1404.  
  1405.  
  1406.     if(NO_OF_PATTERN_SETS == 0)
  1407.     return;
  1408.  
  1409.     /* check whether the pattern to be deleted is the current one */
  1410.  
  1411.     NO_OF_PATTERN_SETS--;
  1412.     if(CURR_PATTERN_SET == setNo){
  1413.     if(CURR_PATTERN_SET == NO_OF_PATTERN_SETS)
  1414.         CURR_PATTERN_SET = 0;          /* make the first one current */
  1415.     else
  1416.         CURR_PATTERN_SET = NO_OF_PATTERN_SETS;
  1417.                                        /* make the last one current */
  1418.     if(NO_OF_PATTERN_SETS == 0){       /* it was the only one        */
  1419.         sprintf(buf,"Patternfile ?");
  1420.         ui_xSetLabel(ui_showPattFile, buf);
  1421.         PATTERN_SET_FILE[0] = NULL;
  1422.         XtRemoveAllCallbacks(USEPattFileWidget[0],XtNcallback);
  1423.         XtRemoveAllCallbacks(DELPattFileWidget[0],XtNcallback);
  1424.         tempWidget = XtParent(USEPattFileWidget[0]);
  1425.         XtDestroyWidget(USEPattFileWidget[0]);
  1426.         USEPattFileWidget[0] = 
  1427.         XtCreateManagedWidget("No Files", smeBSBObjectClass, 
  1428.                       tempWidget, NULL, 0);
  1429.         XtAddCallback(USEPattFileWidget[0], XtNcallback, 
  1430.               (XtCallbackProc)ui_rem_usePattSet,(caddr_t)0);
  1431.         tempWidget = XtParent(DELPattFileWidget[0]);
  1432.         XtDestroyWidget(DELPattFileWidget[0]);
  1433.         DELPattFileWidget[0] = 
  1434.         XtCreateManagedWidget("No Files", smeBSBObjectClass, 
  1435.                       tempWidget, NULL, 0);
  1436.         XtAddCallback(DELPattFileWidget[0], XtNcallback, 
  1437.               (XtCallbackProc)ui_rem_delPattSet,(caddr_t)0);
  1438.         if(SubPatPanel == 1)
  1439.         ui_popupDone(tempWidget, UI_POPUP_SUBPATTERN , (caddr_t) 0);
  1440.  
  1441.     }else{
  1442.         sprintf(buf,"%s",PATTERN_SET_FILE[CURR_PATTERN_SET]);
  1443.     }
  1444.     ui_xSetLabel(ui_showPattFile, buf);
  1445.     }
  1446.  
  1447.     /* delete the pattern set now */
  1448.  
  1449.     ui_checkError(krui_deletePatSet(setNo));
  1450.  
  1451.     if(NO_OF_PATTERN_SETS == 0)    return;
  1452.  
  1453.     /* kernel needs resetting of current pattern */
  1454.     if(CURR_PATTERN_SET < setNo)
  1455.     krui_setCurrPatSet(CURR_PATTERN_SET);
  1456.     else
  1457.     krui_setCurrPatSet(--CURR_PATTERN_SET);
  1458.  
  1459.  
  1460.     /* refresh the subpattern panel */
  1461.     
  1462.     ui_rem_defSubPat(button,1,(caddr_t)1);
  1463.  
  1464.  
  1465.     /* Compact the array of pattern file names and relabel the menus*/
  1466.  
  1467.     for(i=setNo; i<NO_OF_PATTERN_SETS; i++){
  1468.     strcpy(PATTERN_SET_FILE[i],PATTERN_SET_FILE[i+1]);
  1469.     XtSetArg(arg[0],XtNlabel,PATTERN_SET_FILE[i]);
  1470.     XtSetValues(USEPattFileWidget[i],arg,1);
  1471.     XtSetValues(DELPattFileWidget[i],arg,1);
  1472.     }
  1473.  
  1474.     /* destroy the widgets corresponding to the deleted pattern */
  1475.  
  1476.     if(NO_OF_PATTERN_SETS > 0){
  1477.     XtRemoveAllCallbacks(USEPattFileWidget[NO_OF_PATTERN_SETS],XtNcallback);
  1478.     XtRemoveAllCallbacks(DELPattFileWidget[NO_OF_PATTERN_SETS],XtNcallback);
  1479.     XtDestroyWidget(USEPattFileWidget[NO_OF_PATTERN_SETS]);
  1480.     XtDestroyWidget(DELPattFileWidget[NO_OF_PATTERN_SETS]);
  1481.     USEPattFileWidget[NO_OF_PATTERN_SETS] = NULL;
  1482.     DELPattFileWidget[NO_OF_PATTERN_SETS] = NULL;
  1483.     }
  1484.  
  1485. }
  1486.  
  1487.  
  1488.  
  1489. /*****************************************************************************
  1490.   FUNCTION : ui_rem_updatePattList
  1491.  
  1492.   PURPOSE  : Updates the lists of available pattern sets.
  1493.              Both the list under the DEL and the USE button are updated.
  1494.   RETURNS  : void
  1495.   NOTES    : Remote panel has to be created before the call to this function
  1496.  
  1497.   UPDATE   : 13.09.1991
  1498. ******************************************************************************/
  1499. void ui_rem_updatePattList (void)
  1500. {
  1501.  
  1502.     Widget entry;
  1503.     int i;
  1504.     int n = 1;
  1505.     Arg arg[10];
  1506.     char temp[80];
  1507.  
  1508.  
  1509.     /* check whether any pattern files are loaded */
  1510.  
  1511.     if(PATTERN_SET_FILE[CURR_PATTERN_SET] != NULL){
  1512.  
  1513.     for(i=0; i<NO_OF_PATTERN_SETS;i++){       /* for all available files */
  1514.         XtSetArg(arg[0],XtNlabel,PATTERN_SET_FILE[i]);
  1515.  
  1516.         /* if the widgets do not exist already, create them now */
  1517.         /* else update only their labels                        */
  1518.  
  1519.         if(USEPattFileWidget[i] == NULL){
  1520.         USEPattFileWidget[i] = 
  1521.             XtCreateManagedWidget(PATTERN_SET_FILE[i],
  1522.                       smeBSBObjectClass,
  1523.                       REM_UFileMenu,NULL,0);
  1524.         XtAddCallback(USEPattFileWidget[i], XtNcallback, 
  1525.                   (XtCallbackProc)ui_rem_usePattSet,(caddr_t)i);
  1526.         }else{
  1527.         XtSetValues(USEPattFileWidget[i],arg,n);
  1528.         }
  1529.  
  1530.         if(DELPattFileWidget[i] == NULL){
  1531.         DELPattFileWidget[i] = 
  1532.             XtCreateManagedWidget(PATTERN_SET_FILE[i],
  1533.                       smeBSBObjectClass,
  1534.                        REM_DFileMenu,NULL,0);
  1535.         XtAddCallback(DELPattFileWidget[i], XtNcallback, 
  1536.                   (XtCallbackProc)ui_rem_delPattSet,(caddr_t)i);
  1537.         }else{
  1538.         XtSetValues(DELPattFileWidget[i],arg,n);
  1539.         }
  1540.     }
  1541.  
  1542.     }else{
  1543.  
  1544.     /* if no files are loaded make a comment */
  1545.     USEPattFileWidget[0] = 
  1546.         XtCreateManagedWidget("No Files",smeBSBObjectClass, 
  1547.                   REM_DFileMenu, NULL, 0);
  1548.     }
  1549. }
  1550.  
  1551.  
  1552.  
  1553. /*****************************************************************************
  1554.   FUNCTION : ui_rem_resetSubPat
  1555.  
  1556.   PURPOSE  : resets the values of the subpattern panel
  1557.   RETURNS  : void
  1558.   NOTES    :
  1559.  
  1560.   UPDATE   : 16.09.1993
  1561. ******************************************************************************/
  1562. static void ui_rem_resetSubPat (void)
  1563. {
  1564.  
  1565.     int                i;
  1566.  
  1567.     for(i=0; i< subIPatDims; i++) subIPatPos[i] = 1;
  1568.     for(i=0; i< subOPatDims; i++) subOPatPos[i] = 1;
  1569.     
  1570.     ui_rem_setSubPatPanel();
  1571.  
  1572. }
  1573.  
  1574.  
  1575. /*****************************************************************************
  1576.   FUNCTION : ui_rem_setSubPatPanel
  1577.  
  1578.   PURPOSE  : sets all values for the subpattern panel
  1579.   RETURNS  : void
  1580.   NOTES    :
  1581.  
  1582.   UPDATE   : 16.09.1993
  1583. ******************************************************************************/
  1584. static void ui_rem_setSubPatPanel (void)
  1585. {
  1586.  
  1587.     char               buf[20];
  1588.     int                i;
  1589.     pattern_set_info   patt_info;
  1590.     pattern_descriptor descrip;
  1591.     krui_err           error;
  1592.  
  1593.     if(SubPatPanel == 1){
  1594.     if((error = krui_GetPatInfo(&patt_info, &descrip))< 0){
  1595.         ui_checkError(error);
  1596.         return;
  1597.     }
  1598.     for (i=0; i< subIPatDims; i++) {
  1599.         sprintf(buf," %d",subIPatPos[i]);
  1600.         ui_xSetLabel(subIPatPosW[i],buf);
  1601.         sprintf(buf," %d",subIPatStep[i]);
  1602.         ui_xSetLabel(subIPatStepW[i],buf);
  1603.         sprintf(buf," %d",descrip.input_dim_sizes[i]);
  1604.         ui_xSetLabel(in_dim_widgets[i],buf);
  1605.     } 
  1606.     for (i=0; i< subOPatDims; i++) {
  1607.         sprintf(buf," %d",subOPatPos[i]);
  1608.         ui_xSetLabel(subOPatPosW[i],buf);
  1609.         sprintf(buf," %d",subOPatStep[i]);
  1610.         ui_xSetLabel(subOPatStepW[i],buf);
  1611.         sprintf(buf," %d",descrip.output_dim_sizes[i]);
  1612.         ui_xSetLabel(out_dim_widgets[i],buf);
  1613.     } 
  1614.     }
  1615.  
  1616.  
  1617. }
  1618.  
  1619. /*****************************************************************************
  1620.   FUNCTION : ui_rem_getSubPatPanel
  1621.  
  1622.   PURPOSE  : read all values from the subpattern panel
  1623.   RETURNS  : void
  1624.   NOTES    :
  1625.  
  1626.   UPDATE   : 16.09.1993
  1627. ******************************************************************************/
  1628. void ui_rem_getSubPatPanel (void)
  1629. {
  1630.     int i;
  1631.  
  1632.     if(SubPatPanel == 1){
  1633.     for(i=0; i<subIPatDims; i++) {
  1634.         subIPatStep[i] = ui_xIntFromAsciiWidget(subIPatStepW[i]);
  1635.         subIPatSize[i] = ui_xIntFromAsciiWidget(subIPatSizeW[i]);
  1636.     }
  1637.     for(i=0; i<subOPatDims; i++) {
  1638.         subOPatStep[i] = ui_xIntFromAsciiWidget(subOPatStepW[i]);
  1639.         subOPatSize[i] = ui_xIntFromAsciiWidget(subOPatSizeW[i]);
  1640.     }
  1641.     }
  1642. }
  1643. /* end of file */
  1644. /* lines: 1656 */
  1645.  
  1646.  
  1647.